fragile base class造句

例句与造句

1. The dependency on XPCOM led to certain dynamic linking issues ( e . g . the fragile base class problem ) which had to be solved before the plugin would work correctly with different browsers.
2. The "'fragile base class problem "'is a fundamental architectural problem of object-oriented programming systems where base classes ( derived classes, may cause the derived classes to malfunction.
3. Like inheritance, delegation allows the sending object to modify the original behavior, but is susceptible to problems analogous to the fragile base class; while forwarding provides stronger encapsulation and avoids these problems; see composition over inheritance.
4. The fragile base class problem has been blamed on open recursion ( dynamic dispatch of methods on this ), with the suggestion that invoking methods on this default to closed recursion ( static dispatch, early binding ) rather than open recursion ( dynamic dispatch, late binding ), only using open recursion when it is specifically requested; external calls ( not using this ) would be dynamically dispatched as usual.
5. However, such changes had to be done very carefully, as other objects based on the same class might be expecting this " wrong " behavior : " wrong " is often dependent on the context . ( This is one form of the fragile base class problem . ) Further, in languages like C + +, where subclasses can be compiled separately from superclasses, a change to a superclass can actually break precompiled subclass methods . ( This is another form of the fragile base class problem, and also one form of the fragile binary interface problem .)
6. It's difficult to find fragile base class in a sentence. 用fragile base class造句挺难的
7. However, such changes had to be done very carefully, as other objects based on the same class might be expecting this " wrong " behavior : " wrong " is often dependent on the context . ( This is one form of the fragile base class problem . ) Further, in languages like C + +, where subclasses can be compiled separately from superclasses, a change to a superclass can actually break precompiled subclass methods . ( This is another form of the fragile base class problem, and also one form of the fragile binary interface problem .)